%pylab inline
#import ShapelyChipDesigns as SD
#reload(SD)
################ use local developement version ##############
import imp, os, os.path, sys
sys.path.insert(0, "E:\\IPython2\\141007 Sphinx and ShapelyChipDesigns\\try4\\src")
def reload_rm(module_name):
os.system('rm ' + str(module_name) + '.pyc')
reload(module_name)
def import_(filename):
path, name = os.path.split(filename)
name, ext = os.path.splitext(name)
print 'Before: %s in sys.modules ==' % name, name in sys.modules
file, filename, data = imp.find_module(name, [path])
print path
mod = imp.load_module(name, file, filename, data)
print 'After: %s in sys.modules ==' % name, name in sys.modules
return mod
rePath = imp.find_module('ShapelyChipDesigns')[1]
SD = import_(rePath)
SD.__file__
maskname = 'M34 '
chipheight = 2000
chipwidth = 7000
RWC, RWG = 10, 4.5 # Lars' thesis
epsilon = 5.8 # Lars' thesis
c0 = 299792458
um = 1e-6
GHz = 1e9
### Left and right coupling capacitor:
wc = RWC
wGgap = RWG
ltaper = 100
wgap = 3
wGfinger = 7
n1 = 2
n2 = 2
wfinger = 3
lfinger = 42
CKL = SD.MakeFingercapacitor(n1, n2, wfinger, lfinger, wgap,ltaper, wc, wGgap, wGfinger)
CKR = CKL.make_copy()
figure(figsize=(4,4))
CKR.show_info()
SD.mouseshow()
### Center capacitor
wc = RWC
wGgap = RWG
ltaper = 100
wgap = 3
wGfinger = 7
n1 = 2
n2 = 2
wfinger = 3
lfinger = 42
CJ = SD.MakeFingercapacitor(n2, n1, wfinger, lfinger, wgap,ltaper, wc, wGgap, wGfinger)
x, y = SD.anker(CJ.get_polygons('BOUNDARY')[0], 'center')
CJ.add_anker([x,y], 'center')
CJ.show_info()
##### Parameters ########
l = 100 # wiggle height
r = 16 # wiggle radius
n = 11 # number of wiggles
p = 10 # resolution
WIR = 19 # island-reservoir space between the fingers
W = 10 # gap width
IRH = 130 # island + reservoir height
IRW = 325 # island + reservoir width
BH = IRH+2*W # black box height
BW = IRW+2*W # black box width
JJboxw = 26
########### Make the Transmon qubit ########
CX, CY = SD.wiggled_line(l,r,n,p)
T = SD.LineString(zip(CX, CY))
T = T.buffer(WIR/2.)
B = SD.mybox([0,0], IRW, IRH)
BB = SD.mybox([0,0],BW,BH)
BB = SD.translate(BB,xoff=0.5*(IRW-BW), yoff=0.5*(IRH-BH))
cx, cy = SD.anker(T, 'center')
bx, by = SD.anker(B, 'center')
T = SD.translate(T, bx-cx, by-cy)
x,y = SD.anker(T,'center')
T = SD.scale(T, yfact = -1)
# shrink one finger:
xv = linspace(-JJboxw/2., JJboxw/2.)
jjb = SD.LineString(zip(xv,[0]*len(xv)))
JJB = jjb.buffer(JJboxw/2., cap_style=2)
JJB = SD.translate(JJB, xoff=x, yoff=y+0.85*l/2.)
####### Shrinked line: #####
TLnew = SD.unary_union([JJB,T])
TLnew = TLnew.buffer(6).buffer(-6)
TLnew = list(SD.flattenMultipoly(TLnew))[0]
######### Plot: #########
title('TMON: Parts + Shorten one finger')
SD.showPolygons([BB, B])
SD.showPolygons([TLnew], ['green'])
SD.showPolygons([T])
SD.showPolygons([JJB], ['yellow'])
plot(x,y,'o')
grid()
show()
########### Make the Transmon qubit ########
ISLAND,RESERVOIR= B.difference(TLnew)
TMON = SD.BRAND_NEW_STRUCTURE(BB,[])
TMON.EBL.add_polis([RESERVOIR,ISLAND])
########### Ankers ############
P = TMON.BOUNDARY.POLIS
x,y = P[0].boundary.xy
inds = SD.find_vertex('top', x,y)
ytop = [y[i] for i in inds[0]]
ytop = mean(ytop)
xtop = [x[i] for i in inds[0]]
xtop = mean(xtop)
TMON.add_anker([xtop, ytop],
'Flux Line')
#TMON.add_anker([BW/2., ytop],
# 'Flux Line')
P = TMON.BOUNDARY.POLIS
x, y = P[0].centroid.xy
TMON.add_anker([x[0],y[0]],
'EBL markers')
xl, yl = SD.anker(TMON.BOUNDARY.POLIS[0],'lower_left')
TMON.add_anker([xl,yl],
'Resonator LL')
xl, yl = SD.anker(TMON.BOUNDARY.POLIS[0],'lower_right')
TMON.add_anker([xl,yl],
'Resonator LR')
TMON.show_info()
##########################
# larger EBL markers:
mwidth1 = 10
mlength1 = 30
markerlength, markerwidth = mlength1, mwidth1
P0 = SD.LineString([(-0.5,0),(0.5,0)])
M0 = SD.scale(P0, markerlength)
M1 = SD.rotate(M0,90)
M00 = M0.buffer(markerwidth/2., cap_style=3)
M11 = M1.buffer(markerwidth/2., cap_style=3)
MEBL1 = M00.union(M11)
##########################
# smaller EBL markers:
mwidth2 = 2
mlength2 = 12
markerlength, markerwidth = mlength2, mwidth2
P0 = SD.LineString([(-0.5,0),(0.5,0)])
M0 = SD.scale(P0, markerlength)
M1 = SD.rotate(M0,90)
M00 = M0.buffer(markerwidth/2., cap_style=3)
M11 = M1.buffer(markerwidth/2., cap_style=3)
MEBL2 = M00.union(M11)
# marker positions
wfsize = 500
ps1 = SD.get_RegPoly_xy((0,0),
wfsize-2*mlength1,
3)
ps2 = SD.get_RegPoly_xy((0,0),
wfsize-2*mlength1-5*mlength2,
3)
# add outer markers
MARKERS = []
marker = MEBL1
POINTS = zip(ps1[0],ps1[1])
for p in POINTS:
M = SD.translate(marker, p[0],p[1])
MARKERS += [M]
# add inner markers
marker = MEBL2
POINTS = zip(ps2[0], ps2[1])
for p in POINTS:
M = SD.translate(marker,
p[0], p[1])
MARKERS += [M]
EBLMARKERS = SD.BRAND_NEW_STRUCTURE(MARKERS,
[SD.empty()])
EBLMARKERS.add_anker([0,0], 'center')
EBLMARKERS.rotate(-90, EBLMARKERS.ANKERS['center'])
SD.showPolygons(EBLMARKERS.get_polygons())
S = EBLMARKERS
for k in S.ANKERS.keys():
x,y = S.ANKERS[k]
plot(x,y,'o', markersize=5, label=str(k))
grid()
show()
d = 50
w = 5.0
h = 10
o = 25
ti = array([[0,o],
[0,o+h]])
tii = array([[-d,0.0],
[d,0.0]])
TI = SD.MakeTransmissionLine(ti[:,0], ti[:,1], RWC, RWG)
TII = SD.MakeTransmissionLine(tii[:,0], tii[:,1], w, w)
abox = SD.mybox((-(RWC/2.+RWG),0), 2*RWG+RWC, o)
#FLUX = SD.BRAND_NEW_STRUCTURE(TI.BOUNDARY.union(TII.BOUNDARY),TI.STRUCTURE.union(TII.STRUCTURE))
FLUX = SD.BRAND_NEW_STRUCTURE(SD.unary_union([TI.BOUNDARY.POLIS[0],abox]),TI.STRUCTURE.POLIS)
FLUX.add_anker([0,o+h],'to Launcher')
FLUX.add_anker([0,0],'to TMON')
SD.showPolygons(FLUX.get_polygons())
for k in FLUX.ANKERS.keys():
x,y = FLUX.ANKERS[k]
plot(x,y,'o', markersize=5, label=str(k))
legend()
grid()
tight_layout()
SD.mouseshow()
FLUX.ANKERS
FLUX.translate(TMON.ANKERS['Flux Line'],
FLUX.ANKERS['to TMON'])
EBLMARKERS.translate(TMON.ANKERS['EBL markers'],
EBLMARKERS.ANKERS['center'])
TMONPLUS = SD.BRAND_NEW_STRUCTURE(TMON.BOUNDARY.POLIS+EBLMARKERS.BOUNDARY.POLIS+FLUX.BOUNDARY.POLIS,
TMON.STRUCTURE.POLIS+EBLMARKERS.STRUCTURE.POLIS+FLUX.STRUCTURE.POLIS)
S = TMON
for k in S.ANKERS.keys():
x,y = S.ANKERS[k]
TMONPLUS.add_anker([x,y], k)
TMONPLUS.add_anker(FLUX.ANKERS['to Launcher'], 'to Launcher')
TMONPLUS.add_layer(TMON.get_polygons('EBL'), 'EBL')
TMONPLUS.show_info()
SD.mouseshow()
textheight = chipheight/10
X_text = chipwidth/2
Y_text = chipheight/10
mystr = SD.NotebookName()
dig = [int(s) for s in mystr if s.isdigit()]
let = [s for s in mystr.split(str(dig[0]))]
TEXTlist = []
for i in arange(dig[0], dig[1]+2):
textpoly = SD.text2poly(maskname+let[0]+str(i-1), textheight)
llx, lly = SD.anker(textpoly[0],'lower_left')
urx, ury = SD.anker(textpoly[-1],'upper_right')
width = urx - llx
height = (ury - lly)*1.5
textbound = SD.mybox((-0.1*width,-0.1*height),1.2*width,1.2*height)
TEXT = SD.BRAND_NEW_STRUCTURE(textbound, textpoly)
xc, yc = SD.anker(TEXT.BOUNDARY.POLIS[0],'center')
TEXT.translate([X_text,Y_text], [xc,yc])
TEXTlist += [TEXT]
SD.showPolygons(TEXTlist[3].get_polygons())
markerwidth = 4
markerlength = 20
P0 = SD.LineString([(-0.5,0),(0.5,0)])
M0 = SD.scale(P0, markerlength)
M1 = SD.rotate(M0,90)
M00 = M0.buffer(markerwidth/2., cap_style=3)
M11 = M1.buffer(markerwidth/2., cap_style=3)
marker = M00.union(M11)
SD.showPolygons([marker])
distance = 50
n = 5
POINTS = []
MARKERS = []
BOXES = []
abox = SD.mybox((-markerlength/2., -markerlength/2.),
markerlength,
markerlength)
for x in arange(n):
for y in arange(n):
POINTS += [[x*distance,y*distance]]
for p in POINTS:
M = SD.translate(marker, p[0],p[1])
B = SD.translate(abox, p[0],p[1])
scatter(p[0],p[1],s=100)
MARKERS += [M]
BOXES += [B]
CHIPMARKERS = SD.BRAND_NEW_STRUCTURE(MARKERS,[SD.empty()])
########### PHOTOLITHO MARKER #############
factor = n*distance/markerlength
photomarker = SD.scale(marker, factor, factor)
P = SD.unary_union(CHIPMARKERS.BOUNDARY.POLIS)
xc,yc = P.centroid.xy
#xc,yc = CHIPMARKERS.get_ankerpoint('center')
photomarker = SD.translate(photomarker, xc[0], yc[0])
largebox = SD.mybox((-2*markerlength, -2*markerlength),(n+0.5)*distance, (n+0.5)*distance)
photomarkerStruc2 = largebox
for B in BOXES:
photomarker = photomarker.difference(B)
photomarkerStruc2 = photomarkerStruc2.difference(B)
photomarkerStruc2 = photomarkerStruc2.difference(photomarker)
photomarkerStruc2 = SD.flattenMultipoly(photomarkerStruc2)
photomarkerStruc2 = list(photomarkerStruc2)
#SD.showPolygons([photomarker])
CHIPMARKERS.add_layer(photomarker, 'STRUC1')
CHIPMARKERS.add_layer(photomarkerStruc2, 'STRUC2')
CHIPMARKERS.show_info()
SD.mouseshow()
px, py = 0.05, 0.2
c0 = (px*chipwidth, py*chipheight)
c1 = (px*chipwidth, (1-py)*chipheight)
c3 = ((1-px)*chipwidth, (1-py)*chipheight)
c4 = ((1-px)*chipwidth, py*chipheight)
cs = [c0, c1, c3, c4]
aligns = ['lower_left', 'upper_left', 'upper_right', 'lower_right']
for i, c in enumerate(cs):
ax, ay = CHIPMARKERS.BOUNDARY.get_ankerpoint(aligns[i])
CHIPMARKERS.translate(c,[ax,ay])
SD.showPolygons(CHIPMARKERS.get_polygons())
grid()
SD.mouseshow()
A1a, A1b = SD.get_airbridge_poly1()
A2 = SD.get_airbridge_poly2()
SD.showPolygons([A2,A1a, A1b])
length = 8600
width = 2300
wradius = 100
wnumber = 5
reload(SD)
x,y = SD.make_resonator(length,
width,
wradius,
wnumber)
dummy = SD.LineString(zip(x,y))
print dummy.length
print 'Expected resonance frequency: ', c0/(2*(dummy.length+2*ltaper+2*0.6*lfinger)*um*sqrt(epsilon))/GHz
###############################
RESI = SD.MakeTransmissionLine(x,y,RWC,RWG)
####### AIRBRIDGES #####
S1a, S2 = SD.get_airbridge_polys(x,y,
A1a,A2,
10)
S1b, S2 = SD.get_airbridge_polys(x,y,
A1b,A2,
10)
RESI.add_layer(S1a+S1b, 'STRUC1')
RESI.add_layer(S2, 'STRUC2')
######## ANKERS
RESI.add_anker(RESI.ANKERS[0],'left')
RESI.add_anker(RESI.ANKERS[1],'right')
RESI.add_anker(RESI.ANKERS[0]+array([length/50.,0.5*(RWC+RWG)]), 'TMON')
RESII = RESI.make_copy()
print RESII.ANKERS
xc, yc = RESII.BOUNDARY.get_ankerpoint('center')
OldRight = RESII.ANKERS['right']
OldLeft = RESII.ANKERS['left']
RESII.add_anker(OldRight,'left')
RESII.add_anker(OldLeft,'right')
RESII.scale(-1,1,[xc,yc])
############### PLOT #############
figure(figsize=(8,6))
subplot(121)
S = RESI
SD.showPolygons(S.get_polygons())
SD.showPolygons(S.get_polygons('STRUC1'))
SD.showPolygons(S.get_polygons('STRUC2'))
for k in S.ANKERS.keys():
x,y = S.ANKERS[k]
plot(x,y,'o', markersize=10, label=str(k))
legend()
subplot(122)
S = RESII
SD.showPolygons(S.get_polygons())
for k in S.ANKERS.keys():
x,y = S.ANKERS[k]
plot(x,y,'o', markersize=10, label=str(k))
SD.showPolygons(S.get_polygons('STRUC1'))
SD.showPolygons(S.get_polygons('STRUC2'))
legend()
tight_layout()
SD.mouseshow()
RWClarge = 150. # launcher conductor width
RWGlarge = 70. # gap: launcher - groundplane
length = 250. # length of the launcher
length2 = 150. # length of the starter
shuntwidth = 30. # width of the little square on the left side of the starter
##### STRAIGHT STARTER #####
STARTER = SD.MakeTransmissionLine([-length2,0], [0,0],
RWClarge, RWGlarge)
i, o = SD.get_launcher_xy(RWC, RWG, RWClarge, RWGlarge, length)
#plot(i[:,0], i[:,1],'o-')
#plot(o[:,0], o[:,1],'o-')
LAI = SD.Polygon(i)
LAO = SD.Polygon(o)
##### SHUNT ################
GPLANESHUNT = SD.mybox((-length2, -RWClarge/2.), shuntwidth, RWClarge)
##### MAKE THE LAUNCHER ####
LAUNCHER_HR = SD.BRAND_NEW_STRUCTURE([LAO]+STARTER.BOUNDARY.POLIS, \
[LAI]+[STARTER.STRUCTURE.POLIS[0].difference(GPLANESHUNT)])
LAUNCHER_HR.show_info()
##### ANKERS ###############
ax, ay = -length2, 0
LAUNCHER_HR.add_anker([ax,ay],'G')
LAUNCHER_HR.add_anker([length,0], 'to Tline')
LAUNCHER_VU = LAUNCHER_HR.make_copy()
LAUNCHER_VU.rotate(90, [ax,ay])
LAUNCHER_HL = LAUNCHER_HR.make_copy()
LAUNCHER_HL.rotate(180, [ax,ay])
LAUNCHER_VD = LAUNCHER_HR.make_copy()
LAUNCHER_VD.rotate(270, [ax,ay])
######## Plot ##############
subplot(121)
LAUNCHER_HR.show_info()
axis('equal')
###
subplot(122)
LAUNCHER_VD.show_info()
legend()
axis('equal')
SD.mouseshow()
reload(SD)
G = SD.GROUNDPLANE(chipwidth,chipheight)
######### Ankers ###########
G.add_anker([0,chipheight/2.], 'L: HR')
G.add_anker([chipwidth, chipheight/2.], 'L: HL')
G.add_anker([1000, chipheight], 'L: VD (I)')
G.add_anker([6000, chipheight], 'L: VD (II)')
G.add_anker([0.5*chipwidth, 0.5*chipheight], 'C center')
for i, c in enumerate(cs):
G.add_anker(c, 'Chipmarker '+str(i))
######## Plot ##############
for k in G.ANKERS.keys():
x,y = G.ANKERS[k]
plot(x,y,'o', markersize=10, label=str(k))
SD.showPolygons(G.get_polygons())
legend()
tight_layout()
SD.mouseshow()
#import allparts as AP
#reload(AP)
TMONPLUS_II = TMONPLUS.make_copy()
LAUNCHER_VDII = LAUNCHER_VD.make_copy()
parts = SD.all_parts(globals())
names = ['TMONPLUS',
'TMONPLUS_II',
'RESI',
'RESII',
'CKL',
'CKR',
'CJ',
'FLUX',
'LAUNCHER_HR',
'LAUNCHER_HL',
'LAUNCHER_VD',
'LAUNCHER_VDII',
'G']
for name in names:
parts.add_part(name)
parts.get_part_table()
parts.join_parts('G', 'CJ',
['C center','center'])
parts.join_parts('CJ', 'RESI',
['L','right'])
parts.join_parts('CJ', 'RESII',
['R','left'])
parts.join_parts('RESI', 'TMONPLUS',
['TMON','Resonator LL'])
parts.join_parts('RESII', 'TMONPLUS_II',
['TMON','Resonator LR'])
parts.join_parts('RESI', 'CKL',
['left','R'])
parts.join_parts('RESII', 'CKR',
['right','L'])
parts.join_parts('G', 'LAUNCHER_VDII',
['L: VD (II)','G'])
parts.join_parts('G', 'LAUNCHER_VD',
['L: VD (I)','G'])
parts.join_parts('G', 'LAUNCHER_HR',
['L: HR','G'])
parts.join_parts('G', 'LAUNCHER_HL',
['L: HL','G'])
Connections = []
################ CAPACITOR - LAUNCHER CONNECTION #########
aline = SD.connect_v(LAUNCHER_HR.ANKERS['to Tline'],
CKL.ANKERS['L'])
C = SD.MakeTransmissionLine(aline[:,0],aline[:,1],RWC,RWG)
Connections += [C]
aline = SD.connect_v(LAUNCHER_HL.ANKERS['to Tline'],
CKR.ANKERS['R'])
C = SD.MakeTransmissionLine(aline[:,0],aline[:,1],RWC,RWG)
Connections += [C]
from ShapelyChipDesigns import smooth
################ CHARGE LINES ################
### C1
make_smooth = True
aline = SD.connect_h(LAUNCHER_VD.ANKERS['to Tline'],
TMONPLUS.ANKERS['to Launcher'], D=0.39)
if make_smooth: aline = smooth.smoothen(SD.LineString(aline), 100, 50)
x, y = aline[:,0], aline[:,1]
S1a, S2 = SD.get_airbridge_polys(x,y,
A1a,A2,
4)
S1b, S2 = SD.get_airbridge_polys(x,y,
A1b,A2,
4)
B1 = SD.BRAND_NEW_STRUCTURE([],[])
B1.add_layer(S1a+S1b, 'STRUC1')
B1.add_layer(S2, 'STRUC2')
G.add_shapes([B1])
#C = SD.MakeTransmissionLine(aline[:,0],aline[:,1],RWC,RWG)
aline = SD.LineString(aline)
SO = aline.buffer(RWC/2.+RWG,cap_style=2)
SI = aline.buffer(RWC/2.,cap_style=2)
C = SD.BRAND_NEW_STRUCTURE(SO,SI)
Connections += [C]
### C2
aline = SD.connect_h(LAUNCHER_VDII.ANKERS['to Tline'],
TMONPLUS_II.ANKERS['to Launcher'],D=0.39)
s = aline
if make_smooth: aline = smooth.smoothen(SD.LineString(aline), 100, 50)
x, y = aline[:,0], aline[:,1]
A1a, A1b = SD.get_airbridge_poly1()
A2 = SD.get_airbridge_poly2()
'''
A10, A20 = SD.get_airbridge_poly(40, 10,
60, 20)
'''
S1a, S2 = SD.get_airbridge_polys(x,y,
A1a,A2,
4)
S1b, S2 = SD.get_airbridge_polys(x,y,
A1b,A2,
4)
B1 = SD.BRAND_NEW_STRUCTURE([],[])
B1.add_layer(S1a+S1b, 'STRUC1')
B1.add_layer(S2, 'STRUC2')
G.add_shapes([B1])
#C = SD.MakeTransmissionLine(aline[:,0],aline[:,1],RWC,RWG)
aline = SD.LineString(aline)
SO = aline.buffer(RWC/2.+RWG,cap_style=2)
SI = aline.buffer(RWC/2.,cap_style=2)
C = SD.BRAND_NEW_STRUCTURE(SO,SI)
Connections += [C]
for p in parts.D.values()[::-1]:
SD.showPolygons(p.get_polygons())
for C in Connections:
SD.showPolygons(C.get_polygons())
SD.mouseshow()
G.add_shapes(parts.D.values())
G.add_shapes(Connections)
for i, c in enumerate(cs):
ax, ay = CHIPMARKERS.BOUNDARY.get_ankerpoint(aligns[i])
CHIPMARKERS.translate(c,[ax,ay])
G.add_shapes([CHIPMARKERS])
SD.showPolygons(G.get_polygons()+G.get_polygons('STRUC2')+G.get_polygons('STRUC1')+G.get_polygons('EBL'))
axis('scaled')
grid()
SD.mouseshow()
G2 = G.make_copy()
i = 3
G2.add_shapes([TEXTlist[i]])
figure()
SD.showPolygons(G2.get_polygons()+G2.get_polygons('STRUC2')+\
G2.get_polygons('STRUC1')+G2.get_polygons('EBL'))
#SD.showPolygons(TEXTlist[i].get_polygons())
SD.mouseshow()
SD.showPolygons(G2.get_polygons('STRUCTURE'))
G2.layers
G2.layers.keys()
reload_rm(SD)
fig = figure(figsize=(10,4))
G2.show_info()
axis('scaled')
SD.mouseshow()
import mpld3
mpld3.save_html(fig, "E:/IPython2/141007 Sphinx and ShapelyChipDesigns/try4/docs/pyplots/img/E1_E3.html")
fig = figure(figsize=(10,4))
GRnew = SD.invert_polarity(G2.G0[0], G2.get_polygons())
SD.showPolygons(GRnew)
axis('scaled')
SD.mouseshow()
mystr = SD.NotebookName()
dig = [int(s) for s in mystr if s.isdigit()]
let = [s for s in mystr.split(str(dig[0]))]
for i in arange(dig[0], dig[1]+1):
G2 = G.make_copy()
G2.add_shapes([TEXTlist[i]])
SD.savedxf_polylist(G2.get_polygons(), './dxf/'+let[0]+str(i))
SD.savedxf_polylist(G2.get_polygons('STRUC1'), './dxf/'+'layer1_'+let[0]+str(i))
SD.savedxf_polylist(G2.get_polygons('STRUC2'), './dxf/'+'layer2_'+let[0]+str(i))
SD.savedxf_polylist(G2.get_polygons('EBL'), './dxf/'+'layerEBL_'+let[0]+str(i))
SD.savedxf_polylist(G2.get_polygons()+G2.get_polygons('EBL')+G2.get_polygons('STRUC2')+G2.get_polygons('STRUC1'), \
'./dxf/'+'alllayers_'+let[0]+str(i))
GRnew = SD.invert_polarity(G2.G0[0], G2.get_polygons())
SD.savedxf_polylist(GRnew, './dxf/'+'layer0_'+let[0]+str(i))
SD.convert('./dxf/'+'layer1_'+let[0]+str(i)+'.dxf',
'./dxf/'+'layer1_'+let[0]+str(i)+'.dxf')
SD.convert('./dxf/'+'layer2_'+let[0]+str(i)+'.dxf',
'./dxf/'+'layer2_'+let[0]+str(i)+'.dxf')
SD.convert('./dxf/'+'layerEBL_'+let[0]+str(i)+'.dxf',
'./dxf/'+'layerEBL_'+let[0]+str(i)+'.dxf')
SD.convert('./dxf/'+'alllayers_'+let[0]+str(i)+'.dxf',
'./dxf/'+'alllayers_'+let[0]+str(i)+'.dxf')
SD.convert('./dxf/'+'layer0_'+let[0]+str(i)+'.dxf',
'./dxf/'+'layer0_'+let[0]+str(i)+'.dxf')
G2 = G.make_copy()
G2.add_shapes([TEXTlist[3]])
GRnew = SD.invert_polarity(G2.G0[0], G2.get_polygons())
SD.showPolygons(GRnew)
SD.mouseshow()
!ipython nbconvert E1_E3.ipynb --to rst
f = open('E1_E3.rst', 'r')
content = f.read()
f.close()
content = content.replace('%5C','/')
f = open('E1_E3.rst', 'w')
f.write(content)
f.close()
!ipython nbconvert --to html *.ipynb